{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 使用 NumPy 进行数组编辑"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 什么是矢量化？\n",
    "\n",
    "矢量化是 numpy 中的一种强大功能，可以将操作表达为在整个阵列上而不是在各个元素上发生。以下是 Wes McKinney 的简明定义：\n",
    "\n",
    "> 这种用数组表达式替换显式循环的做法通常称为向量化。通常，矢量化数组操作通常比其纯 Python 等价物快一个或两个（或更多）数量级，在任何类型的数值计算中都具有最大的影响。[查看源码](https://www.oreilly.com/library/view/python-for-data/9781449323592/ch04.html)\n",
    "\n",
    "在 Python 中循环数组或任何数据结构时，会涉及很多开销。 NumPy中的向量化操作将内部循环委托给高度优化的 C 和 Fortran 函数，从而实现更清晰，更快速的 Python 代码。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24984\n",
      "24984\n",
      "Speed difference:60.1x\n"
     ]
    }
   ],
   "source": [
    "from timeit import timeit\n",
    "import numpy as np\n",
    "\n",
    "np.random.seed(444)\n",
    "\n",
    "x = np.random.choice([False, True], size = 100000)\n",
    "\n",
    "def count_transitions(x) -> int:\n",
    "    count = 0\n",
    "    for i, j in zip(x[:-1], x[1:]):\n",
    "        if j and not i:\n",
    "            count += 1\n",
    "    return count\n",
    "\n",
    "# 承兑地评估序列中每个元素的真值以及紧随其后的元素：\n",
    "print(count_transitions(x))\n",
    "\n",
    "# 在矢量化形式中，没有明确的 for 循环或直接引用各个元素：\n",
    "print(np.count_nonzero(x[:-1] < x[1:]))\n",
    "\n",
    "# 以下比较两个等效函数在性能方向的差距，向量化的 NumPy 调用胜出约 60 倍\n",
    "setup = 'from __main__ import count_transitions, x; import numpy as np'\n",
    "num = 1000\n",
    "\n",
    "t1 = timeit('count_transitions(x)', setup = setup, number = num)\n",
    "t2 = timeit('np.count_nonzero(x[:-1] < x[1:])', setup = setup, number = num)\n",
    "\n",
    "print('Speed difference:{:0.1f}x'.format(t1 / t2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 技术细节：\n",
    "\n",
    "另一个术语是**矢量处理器**，它与计算机的硬件有关。这里的矢量化指的是用数组表达式替换显式 for 循环的概念，在这种情况下，可以使用低级语言的内部计算。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 买低，卖高\n",
    "\n",
    "考虑以下经典技术面试题：\n",
    "\n",
    "> 假定一只股票的历史价格是一个序列，假设你只允许进行一次购买和一次出售，那么可以获得的最大利润是多少？例如，假设价格 = (20，18，14，17，20，21，15)，最大利润将是 7，从 14 买到 21 卖。\n",
    "\n",
    "存在具有 n 平方**时间复杂度**的解决方案，其包括采用两个价格的每个组合，其中第二价格\"在第一个之后\"并且确定最大差异。\n",
    "\n",
    "然而，还有一个 O(n) 解决方案，它包括迭代序列一次，找出每个价格和运行最小值之间的差异："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def profit(prices):\n",
    "    max_px = 0\n",
    "    min_px = prices[0]\n",
    "    for px in prices[1:]:\n",
    "        min_px = min(min_px, px)\n",
    "        max_px = max(px - min_px, max_px)\n",
    "    return max_px\n",
    "\n",
    "prices = (20, 18, 14, 17, 20, 21, 15)\n",
    "profit(prices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[78.18175006 76.78673365 71.93232085 74.45162841 76.90321758 69.69859522\n",
      " 69.33056829 60.74761961 61.48379151 61.78445476 60.14047928 60.30269029\n",
      " 54.13954845 52.23899599 53.94331469 50.84606205 47.76587351 43.13494379\n",
      " 40.94652884 43.17569731 35.5445586  40.61698308 35.07841631 31.51837463\n",
      " 34.89959405 30.46831099 32.11887903 33.4203897  37.26981848 35.6733898\n",
      " 35.68841653 38.42282652 37.02896729 42.83432714 37.2683375  45.78785183\n",
      " 45.56276395 44.89855728 42.09478037 46.89786561 49.93959315 49.27516259\n",
      " 50.63366901 50.31965572 53.84271533 57.24404713 57.33493303 62.6678849\n",
      " 54.87919691 60.09143998 61.09864389 65.522888   65.30538174 67.07748158\n",
      " 67.98872593 67.58103095 67.04025129 71.57171423 75.57113655 72.43200713\n",
      " 72.754932   73.76782547 74.4985623  72.08162377 72.04122977 72.21810326\n",
      " 73.10444033 69.38265923 71.38244114 70.26855563 68.30142687 67.39813584\n",
      " 66.14988882 65.72715616 66.6532302  63.33249706 67.85206216 65.74167257\n",
      " 66.23959058 59.79009336 63.60744548 62.60184672 62.29017178 64.08909888\n",
      " 62.04853722 55.24815502 57.85779555 57.30441532 55.70195671 54.32612044\n",
      " 56.98938083 54.5549938  55.4354029  52.36788691 57.39606005 53.69038558\n",
      " 51.50256691 49.16180538 46.95929026 49.95302101]\n"
     ]
    }
   ],
   "source": [
    "# 使用 numpy 实现一个准现实的例子\n",
    "import numpy as np\n",
    "\n",
    "prices = np.full(100, fill_value = np.nan)\n",
    "prices[[0, 25, 60, -1]] = [80., 30., 75., 50.]\n",
    "\n",
    "x = np.arange(len(prices))\n",
    "is_valid = ~np.isnan(prices)\n",
    "prices = np.interp(x = x, xp = x[is_valid], fp = prices[is_valid])\n",
    "prices += np.random.randn(len(prices)) * 2\n",
    "\n",
    "print(prices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "mn = np.argmin(prices)\n",
    "mx = mn + np.argmax(prices[mn:])\n",
    "kwargs = {'markersize': 12, 'linestyle': '1'}\n",
    "\n",
    "# fig, ax = plt.subplots()\n",
    "# ax.plot(prices)\n",
    "# ax.set_title('Price History')\n",
    "# ax.set_xlabel('Time')\n",
    "# ax.set_ylabel('Price')\n",
    "# ax.plot(mn, prices[mn], color = 'green', **kwargs)\n",
    "# ax.plot(mx, prices[mx], color = 'red', **kwargs)\n",
    "\n",
    "# plt.plot(prices)\n",
    "# plt.title('Price History')\n",
    "# plt.xlabel('Time')\n",
    "# plt.ylabel('Price')\n",
    "# plt.scatter(mn, prices[mn], 14, 'green')\n",
    "# plt.scatter(mx, prices[mx], 14, 'red')\n",
    "\n",
    "fig = plt.figure(figsize = (8,6), dpi = 72, facecolor = \"white\")\n",
    "axes = plt.subplot(111)\n",
    "\n",
    "axes.plot(mn, prices[mn], color = 'green', linewidth=1,\n",
    "               markersize = 13, marker='.',\n",
    "               markeredgecolor = '0.10', markerfacecolor = 'green')\n",
    "axes.plot(mx, prices[mx], color = 'red', linewidth=1,\n",
    "               markersize = 13, marker='.',\n",
    "               markeredgecolor = '0.10', markerfacecolor = 'red')\n",
    "axes.plot(prices)\n",
    "axes.set_title('Price History')\n",
    "axes.set_xlabel('Time')\n",
    "axes.set_ylabel('Price')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "45.10282555828772\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# 通过 NumPy 实现\n",
    "\n",
    "cummin = np.minimum.accumulate\n",
    "\n",
    "def profit_with_numpy(prices):\n",
    "    prices = np.asarray(prices)\n",
    "    return np.max(prices - cummin(prices))\n",
    "\n",
    "print(profit_with_numpy(prices))\n",
    "print(np.allclose(profit_with_numpy(prices), profit(prices)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[78 31 61 ... 11 26 48]\n"
     ]
    }
   ],
   "source": [
    "# 采用更长的序列，在实时运行时进行比较\n",
    "\n",
    "seq = np.random.randint(0, 100, size = 100000)\n",
    "print(seq)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Speed defference: 138.4x\n"
     ]
    }
   ],
   "source": [
    "setup = ('from __main__ import profit_with_numpy, profit, seq;'\n",
    "        'import numpy as np')\n",
    "num = 250\n",
    "pytime = timeit('profit(seq)', setup = setup, number = num)\n",
    "nptime = timeit('profit_with_numpy(seq)', setup = setup, number = num)\n",
    "print('Speed defference: {:0.1f}x'.format(pytime / nptime))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上部代码实际上有三个遍历序列：\n",
    "\n",
    "- cummin(prices) 具有 O(n) 时间复杂度\n",
    "\n",
    "- prices - cummin(prices) 是 O(n) 的时间复杂度\n",
    "\n",
    "- max(...) 是 O(n) 的时间复杂度\n",
    "\n",
    "这就减少到了 O(n)，因为 O(3n) 在 n 接近无穷大时，是剩下 O(n)，n 占主导地位。\n",
    "\n",
    "这两个函数具有等价的最坏情况时间复杂度，（另：NumPy 函数的空间复杂度要高很多）。\n",
    "\n",
    "#### 注意：\n",
    "\n",
    "虽然理论上的时间复杂度是一个重要的考虑因素，运行时机制也可以发挥很大的作用。NumPy 不仅可以委托给 C，而且通过一些元素操作和线性代数，它还可以利用线程中的计算。但这里有很多因素在起作用，包括所使用的底层库（BLAS/LAPACK/Atlas）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Intermezzo: 理解轴符号\n",
    "\n",
    "在 NumPy 中，轴指向多维数组的单个维度："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11 22 33]\n",
      "[ 6 60]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([[1, 2, 3], [10, 20, 30]])\n",
    "print(arr.sum(axis = 0))\n",
    "print(arr.sum(axis = 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在 Pandas（NumPy 之上构建的库）文档中有：\n",
    "\n",
    "> axis : {'index'(0), 'columns'(1)}\n",
    "\n",
    "AXIS 关键字指定将折叠的数组的维度，而不是将要返回的维度。因此，指定 Axis = 0，意味着第一个轴将折叠；对于二维数组，这意味着每列中的值将被聚合。\n",
    "\n",
    "换句话说，如果 Axis = 0 的数组相加，则会按列计算的方式折叠数组的行。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 广播\n",
    "\n",
    "广播是另一个重要的 NumPy 抽象。两个 NumPy 数组（大小相等）之间的操作是按元素操作的："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.15, 0.5 , 3.5 ])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1.5, 2.5, 3.5])\n",
    "b = np.array([10., 5., 1.])\n",
    "a / b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "广播则用于处理大小不相等的数组：\n",
    "\n",
    "> 术语广播描述了在算术运算期间 NumPy 如何处理具有不同形状的数组。受某些约束条件的限制，较小的数组会在较大的数组中“广播”，以便它们具有兼容的形状。广播提供了一种向量化数组操作的方法，因此循环是在 C 而不是 Python 中进行的。\n",
    "\n",
    "如果只要两个数组，可以用两条简短的规则来描述它们的广播能力：\n",
    "\n",
    "> 在对两个数组进行操作时，NumPy 按元素对它们的形状进行比较。它从尾随维度开始，然后继续前进。两个维度在下列情况下> 是兼容的：\n",
    ">\n",
    "> - 它们是平等的，或者\n",
    ">\n",
    ">\n",
    "> - 其中一个是 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.91950895 23.04482423]\n",
      " [ 2.15426788 23.33315364]\n",
      " [ 2.08053954 19.88797272]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([ 2.05143879, 22.0886502 ])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 减去数组的每个列的平均值，元素平均值：\n",
    "sample = np.random.normal(loc = [2., 20.], scale = [1., 3.5], size = (3, 2))\n",
    "print(sample)\n",
    "\n",
    "mu = sample.mean(axis = 0)\n",
    "mu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sample: (3, 2) | means: (2,)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[-0.13192984,  0.95617403],\n",
       "       [ 0.10282909,  1.24450344],\n",
       "       [ 0.02910075, -2.20067748]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 减去列\n",
    "print('sample:', sample.shape, '| means:', mu.shape)\n",
    "\n",
    "sample - mu"
   ]
  },
  {
   "attachments": {
    "image1.jpg": {
     "image/jpeg": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下面是一个减去列的示例，其中较小的数组被“拉伸”，以便较大的数组的每一行中减去它：\n",
    "\n",
    "![image1.jpg](attachment:image1.jpg)\n",
    "\n",
    "**技术细节：**较小的数组或标量不是按字面意义上在内存中展开的：重复的是计算本身。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "operands could not be broadcast together with shapes (3,2) (3,) ",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-29-281bb40eb3b7>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# 如果出于某种原因，要减去行最小值，会遇到以下错误情况\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0msample\u001b[0m \u001b[1;33m-\u001b[0m \u001b[0msample\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmin\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0maxis\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: operands could not be broadcast together with shapes (3,2) (3,) "
     ]
    }
   ],
   "source": [
    "# 如果出于某种原因，要减去行最小值，会遇到以下错误情况\n",
    "\n",
    "sample - sample.min(axis = 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里的问题是：较小的数组，在其目前的形式下，不能“伸展”，以形式与样本兼容。实际上，我们需要扩展它的维度，以满足上面的广播规则："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.91950895]\n",
      " [2.15426788]\n",
      " [2.08053954]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 0.        , 21.12531529],\n",
       "       [ 0.        , 21.17888576],\n",
       "       [ 0.        , 17.80743319]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(sample.min(axis = 1)[:, None])\n",
    "\n",
    "sample - sample.min(axis = 1)[:, None]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 注意：\n",
    "\n",
    "\\[:, None] 是一种扩展数组维度的方法，用于创建长度为 1 的轴。 np.newaxis 是 None 的别名"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "还有一些更为复杂的案例。下面是任何形状的任意数量的数组可以一起广播的更严格的定义：\n",
    "\n",
    "> 如果以下规则产生有效结果，则一组数组被称为“可广播”到相同的形状，这意味着**以下之一为真**时：\n",
    "> \n",
    "> - 1、矩阵都具有完全相同的形状\n",
    "> \n",
    "> \n",
    "> - 2、矩阵都具有相同数量的维度，每个维度的长度是公共长度或 1\n",
    "> \n",
    "> \n",
    "> - 3、具有太少尺寸的矩列可以使其形状前面具有长度为 1 的尺寸以满足属性 # 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 1)\n",
      "(1, 10)\n",
      "(10, 1)\n",
      "(1,)\n"
     ]
    }
   ],
   "source": [
    "a = np.sin(np.arange(10)[:, None])\n",
    "b = np.random.randn(1, 10)\n",
    "c = np.full_like(a, 10)\n",
    "d = 8\n",
    "\n",
    "arrays = [np.atleast_1d(arr) for arr in (a, b, c, d)]\n",
    "for arr in arrays:\n",
    "    print(arr.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在我们可以检查标准 # 1。如果所有数组具有相同的形状，则它们的一组形状将缩减为一个元素，因为 set() 构造函数有效地从其输入中删除重复项。这里想让没有达到这个标准："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(set(arr.shape for arr in arrays)) == 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "标准 # 2 的第一部分也失败了，这意味着整个标准失败："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(set((arr.ndim) for arr in arrays)) == 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最后一个标准更复杂一些：\n",
    "\n",
    "> 具有太少尺寸的矩列可以使其形状前面具有长度为 1 的尺寸以满足属性 # 2.\n",
    "\n",
    "为了对此进行编码，你可以首先确定最高维数组的维度，然后将其添加到每个形状元组，直到所有数组具有相同的维度："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  1],\n",
       "       [ 1, 10],\n",
       "       [10,  1],\n",
       "       [ 1,  1]])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "maxdim = max(arr.ndim for arr in arrays)\n",
    "shapes = np.array([(1,) * (maxdim - arr.ndim) + arr.shape for arr in arrays])\n",
    "shapes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最后，你需要测试每个维度的长度是否是公共长度，或是 1。这样做的一个技巧是首先在“相等”的位置屏蔽“shape-tuples”数组。然后，你可以检查 peak-to-peak(np.ptp())列方差是否都为零："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "masked = np.ma.masked_where(shapes == 1, shapes)\n",
    "np.all(masked.ptp(axis = 0) == 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 将整个逻辑封装在单个函数中：\n",
    "def can_broadcast(*arrays) -> bool:\n",
    "    arrays = [np.atleast_1d(arr) for arr in arrays]\n",
    "    if len(set(arr.shape for arr in arrays)) == 1:\n",
    "        return True\n",
    "    if len(set((arr.ndim) for arr in arrays)) == 1:\n",
    "        return True\n",
    "    maxdim = max(arr.ndim for arr in arrays)\n",
    "    shapes = np.array([(1,) * (maxdim - arr.ndim) + arr.shape for arr in arrays])\n",
    "    masked = np.ma.masked_where(shapes == 1, shapes)\n",
    "    return np.all(masked.ptp(axis = 0) == 0)\n",
    "\n",
    "can_broadcast(a, b, c, d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 可以选择一个快捷方式并使用 np.cast() 来进行这种健全性检查，尽管它并不是为此目的而显式设计的：\n",
    "def can_broadcast(*arrays) -> bool:\n",
    "    try:\n",
    "        np.broadcast(*arrays)\n",
    "        return True\n",
    "    except ValueError:\n",
    "        return False\n",
    "\n",
    "can_broadcast(a, b, c, d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 矩阵变成实际应用：示例\n",
    "\n",
    "在以下 3 个示例中，使用矢量化和广播来处理一些实际应用程序。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 聚类算法\n",
    "\n",
    "机器学习是一个可以经常利用矢量化和广播的领域。假设有三角形的顶点（每行是 x, y 坐标）：\n",
    "\n",
    "> tri = np.array([[1, 1], [3, 1], [2, 3]])\n",
    "\n",
    "这个 **\"簇\"** 的质心是 (x, y) 坐标，它是每列的算数平均值："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2.        , 1.66666667])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "tri = np.array([[1, 1], [3, 1], [2, 3]])\n",
    "centroid = tri.mean(axis = 0)\n",
    "centroid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQwAAAD8CAYAAACCaZo+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3VuMZVed3/Hvv86pqq5bd1XXteO2sTMzmh5gwq1lG5FxzE1yCLIfMJHngcEoqDUEe2CCFBCaAcHwMopENNgoTo+MYiLEMAMEOZZRRAYTTCQa2pZt7HEzOMODm+6u66nrue3LPw9r7127y6e6dlXXOftc/h+p5Lrs6vr71Kl//WqttdcSVcUYY7Loy7sAY0znsIZhjMnMGoYxJjNrGMaYzKxhGGMys4ZhjMlsz4YhIkdE5Gci8ryIvCQiX2hwzf0isigiz0UvH21OucaYPBUzXFMD3qWqmyLSD/xERL6vqj/dcd23VPWBwy/RGNMu9mwY6lZ2bUZv9kcvttrLmB6UJWEgIgXgGeC3ga+q6rkGl31ARO4A/hH4U1V9tcG/cwY4AzAyMvK2U6dOHbhwY8zBPPPMM0uqOn2Qz5X9LA0XkXHgfwAPquqLqfdPApuqWhORPwb+raq+61r/1unTp/X8+fMHqdkYcx1E5BlVPX2Qz93XLImqrgI/Au7a8f5lVa1Fb/418LaDFGOMaW9ZZkmmo2SBiAwB7wEu7LjmROrNu4GXD7NIY0x7yDKGcQJ4LBrH6AP+VlWfEJEvAudV9XHgT0TkbsAHVoD7m1WwMSY/+xrDOEw2hmFMPlo2hmGM6W3WMIwxmVnDMMZkZg3DGJOZNQxjTGbWMIwxmVnDMMZkZg3DGJOZNQxjTGbWMIwxmVnDMMZkZg3DGJOZNQxjTGbWMIwxmVnDMMZkZg3DGJOZNQxjTGbWMIwxmVnDMMZkZg3DGJOZNQxjTGbWMIwxmVnDMMZkZg3DGJOZNQxjTGbWMMz+lUoQBHlXYXJgDcPsjyorL1zkwv+ZZ3Ex72JMq2U5vf2IiPxMRJ4XkZdE5AsNrhkUkW+JyCsick5Ebm5GsSZfFy7Avf9qkX/z3jofvXuBm0/6vPe97v2mN2RJGDXgXar6JuDNwF0icvuOa/4dUFLV3wb+M/CXh1umyduFC3D7rSG/evoKdQ8qWwHj9Xn+/u/httusafSKPRuGOpvRm/3Ry84j3+8BHote/zbwbhGRQ6vS5O6BB+DIxiJFvOR9MyxQUI+NDXjwwRyLMy2TaQxDRAoi8hywAPxAVc/tuOQG4FUAVfWBNWDyMAs1+VlchP/7dMgsV6L3hAD0ETLHFVTh6adhaSm/Gk1rZGoYqhqo6puBk8CtIvLGHZc0ShM7UwgickZEzovI+UUbMesY8/NwcmCBIj4AxdE6UnSvT+NSx8AAXLlyrX/FdIN9zZKo6irwI+CuHR+6CNwIICJF4Biw0uDzz6rqaVU9PT09faCCTevNTgVM1Fw3kEKADPgUhuvubZQTXKZeh7m5PKs0rZBllmRaRMaj14eA9wA7h7geBz4cvX4v8ENVfU3CMJ1pOpznbW8OEKAwFDWKYphKGUu88x11pqZyLNK0RJaEcQJ4SkReAH6OG8N4QkS+KCJ3R9c8CkyKyCvAfwA+05xyTcv5Piws8B8/DSNHA2Rwe8FWYaSGAKMjykOfvZxfjaZlintdoKovAG9p8P7PpV6vAh883NJMW5ifhyDglpvhP32lzn/9Gvzyl1Asgu8rb3m9z6c/VeSWiWWozcHgYN4Vmybas2GYHhalC4BK3WdiOuAzn4ZS3zhbF9cZHwuZnKhx02QRVOHSJbjllpyLNs1kS8PN7q5cgdBNoS5vubEL+oSh372BubfOMjoGNV/ZqLqxDFZWoFrNqVjTCtYwTGOeR3yzSLnuU6m7xuFPTkF/P/7UNBQLAKxs1UjGuC9dyqVc0xrWMExjly83TBf+9Gz0el/yej2dMkolKJdbXa1pEWsY5rXq9WTZ5lbNp5qki2k32hlxacO9vbJV304Zl23GpFtZwzCvdfmyG8TENQIACn340zNXX9fXhzfjVmt5gbIep4zVVdjaalW1poWsYZir1WqwvAzARtWn6jVOF7Hg+CTa3w/YWEYvsIZhrpZKF6Wtmntfo3QRE8GfdSnDD2CtEt3Nur4Om5uNP8d0LGsYZlu1elW6qPmucfjTs1Ao7PppwcRxdGAAgFK5ThhayuhW1jDMttQP+EqcLooFN4V6LbuljI0N92K6hjUM41QqbkoU2Kh61NPpom/vp0kwPoFGy8ItZXQvaxjGiX6wVZXlzWhmpL/opk6zEMGbPQFAEMJqJfo3Njdhbe2wqzU5sYZh3EKr1VUA1qs+XuDSgZcxXcTC8XH0yBEAVssegaWMrmMNw1yVLuKxC+3vJ8iaLlK8aCwjCGGtHKWMVEMync0aRq9L/cmwVvHwo+0u/Nk5OMA+zuGxcXRoCIBSxcMP3DoOSxndwRpGr4t+kMNQKUWJQAcGCCaOH/ifjFNGGMJqPGOSGlQ1ncsaRi9LTXseRrqIhUePocPDgBvLuCpl2M6NHc0aRi9rlC4GBwnGJ677n/bm3IyJKpTiGZNq1e2ZYTqWNYxelVq6vVqpE4cAf+b60kUsHB0jHB0FYK3s48VfILX03HQeaxi96je/ASAIldWyG2fQI0cIJq4/XcTi1Z+qJAkmfXOb6TzWMHrR6mqyyc1aeTtdxIOVhyUcGSUcGwNgveLj+ZYyOp01jF4UjV0EoVKKZjF0aIjw2PihfykvlTJW4pSR2qDHdBZrGL2mVHJTnMT3fLh3H3a6iOnwCOHRY4C7A7YeT8WktgA0ncMaRi+JjwIA/CDcHrsYHk5+qJvhqpSxFa3LSG0ybDqHNYxeUiolxwCUKvVkGCGeAm0WHRoiiP7c2az51OKUkTrGwHQGaxi9IpUuvCBkrez23wxHRwlHx5r+5dMzJiubUcpIHZRkOoM1jF6xvOymNIHV8na68Js0drGTHjlCML5LygiCa3ymaSfWMHqBarL1v+eHrFWidDE2Rjgy2rIy/NkTEK0JW4n33AgCSxkdZM+GISI3ishTIvKyiLwkIp9ocM2dIrImIs9FL59r9G+ZnCwtualM3NRmMnbRonQR08HB5Ka2zVpA1YuSxfy8+/PEtL0shzH7wKdU9VkRGQOeEZEfqOo/7LjuaVV9/+GXaK5LGCbpou4HyQll4dhRdHik5eX4M3MUSiug7syTfzY+5FLG/DzccEPL6zH7s2fCUNXLqvps9PoG8DJg39lOsbTkpjBxU5rbMyOtTRcxHRggOD4JwFYtoOJFyWJhwVJGB9jXGIaI3Ay8BTjX4MNvF5HnReT7IvKGXT7/jIicF5HzizYH33ypdFHzAzZr7gcyODaODg3nVpY3M5eMZST7h4ahGwA1bS1zwxCRUeA7wCdVdX3Hh58FXqeqbwIeAr7X6N9Q1bOqelpVT09P77F1vbl+qd/apVS68GdmcywKSG3/V6mHlOtRslhcTNKQaU+ZGoaI9OOaxTdU9bs7P66q66q6Gb3+JNAvIvvfENIcnnhcAJcu4rGLYHx7C708uQ2GXcxIToe3lNH2ssySCPAo8LKqfnmXa+ai6xCRW6N/1+5hzlMqXSRTmBLtd9EO+vvdea1AtR6yVUuljGhGx7SfLLMk7wA+BPxCRJ6L3vdZ4CYAVX0EuBf4mIj4QAW4T9XuX85NKl1UvYDNmpu+DMYnkmMA2oE/PUNxZQmCkJWtOiODxe01I697Xd7lmQb2bBiq+hOSIapdr3kYePiwijLXaX4+WT25stWG6SJWLOJPTlNcmKfqhWzWfEYHi25V6twcRCepmfZhKz27je8n6aLi+WzF6eL4ZHKUYTvxp2eg4J6GyWnxqZWppr1Yw+g2qTtAk1vJJTojtR0VCvhTMwBUPU0GZ1leTu6sNe3DGkY3Se0xUa77lON0MTmFDgzkWdk1+VPTUCwAqVPjwQ4/akPWMLpJKl0kU5V94qYw21mhkCSguq9sVKNklNodzLQHaxjdol5P0sVWzadad43Dn5yC/v48K8vE1enG4Jc36ySTbJYy2oo1jG6R2ol7JZUu2nbsYqe+viQJeYGyHo9lpHY4N/mzhtENUmd9bNZ8ql6ULqZmoJhlqU17CI5PolEaWtmqWcpoQ9YwukEqXSRTk4U+N2XZSfr6kvtc/MCd9wq40+W3tnIszMSsYXS6ajVJFxtVn6rnGoc/NQOFQp6VHUhwfDKZ0XHHIEQpIzqpzeTLGkanSy1wStJFseCmKjuRSLLPqB/AWjxjkjpp3uTHGkYnq1SS09A3qh41P0oX07MdmS5iwfhEsip1NZ0ybCwjd9YwOln0A6Sq2zMj/UU3RdnJRJL7XvzAnS4PuNPm13duxWJayRpGpyqX3ZQj8RGE7rew22ei87+twcT2nbWrZY/AUkZb6PxnVq9KpYvleOyiv5jsl9kNvChlBKE7ZR5wsyVrazlW1dusYXSi1A/NWsUjPhPIm5nrinQRC1O7g5UqljLaQfc8u3pJKl2Uot+82t/fVekiFp+dEoZuABRwf46VSjlW1busYXSa1MDfaipd+HMnQK65z1FHCo8eQ4fdDuelsocfRIc3X7qULFYzrWMNo9NEC5jCUJPfuDowQDA+kWdVTeWlDnIuxTMm1aqljBxYw+gk6+suYXD12IU7s7T70kUsHDtKOOJOaVsr+3iWMnJjDaOTRGMXQZgauxgcTE5F72b+3AnA9YdkLKNWSxaumdawhtEpUjdgrZXrxL9kvS5PF7FwZJRwbAyAtYqP51vKyIM1jE6RThfRXZw6NETYA+ki1nAso15358ealrCG0QlSm8i4eyvcu+MfoF6hwyOEY0cBWK/41ONBnMuXk60JTXNZw2h3qkm68IOQ1ThdDA8THj2WZ2W5iE+dV03tiu55ljJaxBpGu0tthLta8Xo2XcR0aLtRbtZ8anHKSG2AbJrHGkY7S6ULLwhZLbvfqOHIdjTvRVeNZaRTxsJCjlX1BmsY7WxlxU0d4sYu4skAv0fTRUyHhpKp5I1qKmWkjog0zZHl9PYbReQpEXlZRF4SkU80uEZE5Csi8oqIvCAib21OuT0kdVyg54esVdwu2uHoKOHoWJ6VtYX0ObErm1HK8H1LGU2WJWH4wKdU9feA24GPi8jrd1zzr4HfiV7OAP/lUKvsRUtLSbooVbbThRctYOp1euQIwYRbDu92SreU0Qp7NgxVvayqz0avbwAvAzfsuOwe4Ovq/BQYFxF7Zh9UGLpBPFy6WI/TxdhRdHgkz8raij8zB9GatWTHsSBIDqM2h29fYxgicjPwFuDcjg/dALyaevsir20qiMgZETkvIucXo1O6TANLS25BEu7Iw+100dtjFzvp4CDBxHEAtmoBFS86/Gh+3v15Yg5d5oYhIqPAd4BPqurOjRUbrU1+zXpdVT2rqqdV9fT0dIfuat1sqXRR9wM2a1G6OHoMHRrOs7K2dHXKiMYyUo+hOVyZGoaI9OOaxTdU9bsNLrkI3Jh6+yRg2yIdxOKimyLE/QAk6aLHZ0Z2owMDBNGmx+VaQKUeJYvU42gOT5ZZEgEeBV5W1S/vctnjwB9FsyW3A2uqenmXa81ugiD5zVjzAzai80WD1FZ15rXcxscuZizFYxmWMpoiy8Gb7wA+BPxCRJ6L3vdZ4CYAVX0EeBJ4H/AKUAY+cvil9oCFheRv72SqkKunEE0D/f34k1MUFxep1kO2aj4jg0WXMmZnITpJzVy/PRuGqv6ExmMU6WsU+PhhFdWTUqP7VW977CK93b7ZnT89S3F5CUJ3RsvIYNGtZblyBW66Ke/yuoat9GwXqfUDyRShWLrIrFjEn3QD6VUvTBpuej2LuX7WMNpBaoVixfPZqrnGEUwcT44MNHvzZ2ah4J7SyTmzqRWz5vpZw2gHV6WLaOzC0sX+FQru1Hqg6mkyaMzysts02Fw3axh5S91lWan7lON0MTmF2mDdvvlT01B0B1EnKQMsZRwSaxh5S+3jsByPXfSJmyo0+5dKGTVf2ahGiW1lJdlXxBycNYw81etu6g8o130qddc4/Mkp6O/Ps7KOlk4ZK1t1NF79ZinjulnDyNOVK8mO18ub2+nCt3Rxffr6koOc635qLKNUSvZGNQdjDSMvqd2u3e3ZcbqYhmKW9XTmWoLjk9DvHserUoYd5HxdrGHk5fLlJF0kg3OFPvzpmRyL6iKplOEFynqcMlLnu5j9s4aRh1rNTfXhtpireq5x+FMzli4OUXB8Eo3Ggla2apYyDoE1jDykTutK0kWx4AbrzOERSfY/9QOSIxrSZ9Sa/bGG0WrVanIe6EbVo+an0kWhkGdlXSmYOJ6sZ3GHQEUp4ze/ybGqzmUNo9WiOKyq2/eMdFi6uLB0gQ/+3b1cWLqQdyl7E3Gn2+NSxlqcMjY3XdIw+2INo5XKZTe1hxu7qMfpYnoW+jrjW3Fh6QJnnjjDr1d/zZknznRE0wjGx5N7ckrplGFjGfvWGc/SbhEtHLoqXfQX3UKtDhA3i7LnZhnK3lZnNA0Rd8o9EISwGh/kvLXlZk1MZtYwWmVryx2qDKxXfbzA/ZbzZuY6Il3sbBaxTmka4fh4sq9IqewRWMo4kPZ/pnaLq8Yu3MyI9ve7BUZtbrdmEeuUphHvixqGbgAUcH8mRo3c7M0aRiukBthWKx7xyX7+7BzINTczy91ezSLWCU0jPDaODrud1933ITq82VJGZtYwWiF6QoahJr/ZdGAgOVOjnf35U3+2Z7OIlb0t/vypP2tyRdfnqpQRz5hUKslUt7k2axjNtrHhXnBTep2ULgD+4p1fYrg/22lrw/0j/MU7v9Tkiq5POHaUcMT9/6yWUykjtVTf7M4aRrNFC4TCUCnF6WJwkGB8Is+qMjs1dYqz7z+7Z9MY7h/h7PvPcmrqVIsqO7h49acqyfckvaDO7M4aRjOlbnRardSJf5l5syc6Il3E9moandQsAMLRMcLRUQDWKj6epYzMrGE0UzR2EYRKqez+XtYjRwjHx/Os6kB2axqd1ixiDVNG6qZA05g1jGZZXU02a3H3MLh3d/KRhzubRqc2C4BwZJRwbAyA9YqP51vKyMIaRrNE6cIPwmQ0XoeGCI91XrpIi5vGLeO3dGyziHlzbvWnKqzEKSO1baJ5LWsYzVAqJRvOrla87XQRPUE73ampU/zdB7/d0c0CQIeGCY8eA+J7e6IprNTGzOZq1jAOm+rV6SIauwhHRgjHjuZZmWnAS41lJGfCeJ6ljF1kOb39ayKyICIv7vLxO0VkTUSei14+d/hldpCVleTQnFKlnvw57Hfw2EU306EhgujPxI2qT81SxjVlSRj/Dbhrj2ueVtU3Ry9fvP6yOlTqWD4vCFkru30kw9FRwtGxPCsz15Bu5iubUcpIHV9ptu3ZMFT1x4CtaMlieTk5+LdUtnTRKfTIEYIJt5Bus7YjZURHWBrnsMYw3i4iz4vI90XkDbtdJCJnROS8iJxf7La/EdPpwg9Zr0TpYmyMcGQ0z8pMBv7MHERr6VbiM2KCwJ17axKH0TCeBV6nqm8CHgK+t9uFqnpWVU+r6unp6c7Zki6TpSU3JYeboovTRSevu+glOjiY3Ay4WQuoelGyWFhwf54Y4BAahqquq+pm9PqTQL+IdMYWUoclDJN0UfeD5KSt8OgxdDjbjVsmf+mUkZxzaynjKtfdMERkTsTdGCEit0b/Zm+tr11cdFNxuKk5SxedSQcGkg2NyrWASj1KFgsLyfe31+15ao6IfBO4E5gSkYvA54F+AFV9BLgX+JiI+EAFuE+1h9bWhqEbHANqqXQRHBtHh4byrMwcgDczR6G0AqGyvFXn5EDRfY/n5+HkybzLy92eDUNV/3CPjz8MPHxoFXWa1N+4yZQcNjPSsfr78SenKC4uUqmHlOs+wwNF932enYXoJLVeZSs9r0cQXJUuNmtRukhtOGs6jzv2wQ1mJGMZqVmwXmYN43osLCTz9MlUnJAcnGM6VLGIP+lm8ar1kK3oF0F6JqxXWcM4KN9PRs+rXsBmzTWOYOJ4cmiO6Vz+9AwU3I9HvMu7pQxrGAc3P5+kiyS2SjQ1ZzpfOmV4mgxmp1fz9iJrGAeRus+gUvcpx+ni+GRy8K/pfOmUUbKUAVjDOJjUnYzpdOFZuuguhYIbAAVq/o6UEd2R3GusYexXaq+Ect2nUneNw5+a7vkpt27kT01DsQCkxjKgZw8/soaxX5cvvzZd9Enym8h0mb6+5Htb95X1+PCj1K5qvcQaxn7U625qDdiq+VTjdDE5DcU918CZDuVPTkG/+/6ubNVJFjL3YMqwhrEfqR2lV+J0Uehzg2Ome/X14UUpwwuU9XgsI7UzfK+whpFV6syKjapP1bN00UuCySk0GqNa2aptp4zoZLteYQ0jq1S6SKbYLF30DpHk/iA/cOfkArC+DpubORbWWtYwsqhWr0oXNd81Dn96FgqFPCszLRRMHE/W2ZTKdcKw98YyrGFkkXpCJFNrxYKbcjO9Y7eUsbHhXnqANYy9VCpuCg3YqHrU0+mizx6+XhOMTyT3CvViyrBn/F6iJ4KqshzfkdpfdFNtpveIJPcLBSGsVqLnxOamG8/octYwrqVcdlNnwHrVxwvcbxPP0kVPCyYmkv1OVsseQdg7Myb2rL+WVLqIxy60v5/A0kXPi/drDUJYiw9yTv2C6VbWMHaztQVra4Ab3IrPtvFn50Akx8JMOwhTe7aWKqmU0eVjGdYwdhPFyzBUStFvEB0YSM6uMCZOGWFI8hxJD5J3I2sYjaSmySxdmN24c2eGATeW4QfR4c2XLiWL/LqNNYxGolh5VboYHCQYn8izKtOG4pShCqV4xqRa7dqUYQ1jp9RS39VKnfiXhjsVy9KFuVo4dpRw1J2du1b28bo8ZVjD2ClKF0GorJbdSr706d7G7OSnUsZqPJaRulmxm1jDSFtbc7MjuKmy+JeFHXloriUcGSUcGwNgreLj+dETJ3XDYrewhpEWzYwEoVKK7hPQoSHCY+N5VmU6QHosYyVOGakNl7qFNYzI0q9KvPKLCqVSfI+Ae7+lC5OFDo8Qjh0F3B3NdT+gVIJf/fgyi/NhztUdniyHMX8NeD+woKpvbPBxAf4KeB9QBu5X1WcPu9BmuXABHvi4svz0JY4OQN0Lef1tHh/+MMz91jDh0WN5l2g6hDc3x+DGOpcuwV9+yePFnxcYGPD4J2+JU3fM8NBDcOpU3lVeH9nroHURuQPYBL6+S8N4H/AgrmHcBvyVqt621xc+ffq0nj9//kBFH5YLF+C226C4vsLN/BqAwnCVviGfoSPwhS/AiZMWwkx2ly+GfP7zUKmCVxqCsIBPkRf5fUaP9nHuXP5NQ0SeUdXTB/ncLKe3/1hEbr7GJffgmokCPxWRcRE5oaptf9rLAw/AxrryeqLlvBIigz6o+4Y/9nX4zKe7J06a5nvsMffcQaE47OFvFijiM80CCxtzPPgg/OAHeVd5cIexGeUNwKupty9G72vrhrG4CD/5CRxnmUHcjWVSCNFakThzXXgexINj9leJyWB1DS68AKGXfq8CwizzLOo0Tz9dYGkJpjr0/sXDaBiNVjM1/DtHRM4AZwBuuummQ/jSBzc/D4MDyonadl9Tv0jgbz8kR4aBKkyfzKFA03HW5qHoQ7XBRuJFfGZYYGvgBFeudG7DOIw/0C8CN6bePgk0vGVPVc+q6mlVPT09ne/2drOzMFZbYoD6rtd4Htid7CaryUk3k7qbWeYJaj5zHTzxdhgJ43HgARH5G9yg51onjF9MT8Pv/ctJnvrh8YZxSIB33wETd7a4MNOxJoCxP4Af/rBxxBbgnX/Q17HpArJNq34TuBOYEpGLwOeBfgBVfQR4EjdD8gpuWvUjzSr2sD301T5uu83dmJqeLBKB0TH4q4cB2xTc7MNXvso1n1MPPZxfbYdhzz9JVPUPVfWEqvar6klVfVRVH4maBep8XFV/S1V/X1XznSvdh1On4Nw5ePe7YXAQxsbcf9/zHtpi+st0nm5/Tu25DqNZ2mEdRtrSEly5AnNznTsgZdpLuz6nmroOo1dMTbXXN9V0vm58TtkyRmNMZtYwjDGZWcMwxmRmDcMYk5k1DGNMZtYwjDGZWcMwxmRmDcMYk5k1DGNMZtYwjDGZWcMwxmRmDcMYk5k1DGNMZtYwjDGZWcMwxmRmDcMYk5k1DGNMZtYwjDGZWcMwxmRmDcMYk5k1DGNMZtYwjDGZWcMwxmRmDcMYk5k1DGNMZtYwjDGZZWoYInKXiPxSRF4Rkc80+Pj9IrIoIs9FLx89/FKNMXnb82xVESkAXwXeC1wEfi4ij6vqP+y49Fuq+kATajTGtIksCeNW4BVV/SdVrQN/A9zT3LKMMe0oy+ntNwCvpt6+CNzW4LoPiMgdwD8Cf6qqr+68QETOAGeiN2si8uI+6222KWAp7yIaaMe6rKZs2rGm3z3oJ2ZpGNLgfbrj7f8JfFNVayLyx8BjwLte80mqZ4GzACJyXlVP77PepmrHmqA967KasmnXmg76uVn+JLkI3Jh6+yRwKX2Bqi6rai1686+Btx20IGNM+8rSMH4O/I6I3CIiA8B9wOPpC0TkROrNu4GXD69EY0y72PNPElX1ReQB4H8BBeBrqvqSiHwROK+qjwN/IiJ3Az6wAtyf4WufPXjZTdOONUF71mU1ZdNVNYnqzuEIY4xpzFZ6GmMys4ZhjMms6Q2jHZeVi8jXRGRht3Ug4nwlqvkFEXlrG9R0p4ispR6nz7WgphtF5CkReVlEXhKRTzS4pqWPVcaaWvpYicgREfmZiDwf1fSFBtcMisi3osfpnIjc3AY17f9nT1Wb9oIbJP1/wD8HBoDngdfvuOZ+4OFm1tGgrjuAtwIv7vLx9wHfx61BuR041wY13Qk80eLH6QTw1uj1MdyivJ3fv5Y+VhlrauljFf2/j0av9wPngNt3XPPvgUei1+/D3UqRd037/tlrdsJoy2Xlqvpj3GzObu4Bvq7OT4HxHVPHedTUcqp6WVWfjV7fwE2X37DjspY+Vhlraqno/30zerM/etk5m3APbkEjwLeBd4tIo0WRraxp35rdMBotK2/0zf1AFGe/LSI3NvgsTrqlAAABzUlEQVR4q2Wtu9XeHkXM74vIG1r5haMI/Rbcb6q03B6ra9QELX6sRKQgIs8BC8APVHXXx0lVfWANmMy5Jtjnz16zG0bWZeU3q+q/AP432104T1nqbrVngdep6puAh4DvteoLi8go8B3gk6q6vvPDDT6l6Y/VHjW1/LFS1UBV34xbCX2riLxxZ8mNPi3nmvb9s9fshtGpy8r3rLvVVHU9jpiq+iTQLyJTzf66ItKP+8H8hqp+t8ElLX+s9qopr8cq+nqrwI+Au3Z8KHmcRKQIHKNFf4LuVtNBfvaa3TA6dVn548AfRTMAtwNrqno5z4JEZC7+m1dEbsV975ab/DUFeBR4WVW/vMtlLX2sstTU6sdKRKZFZDx6fQh4D3Bhx2WPAx+OXr8X+KFGI4951XSQn70sd6semDZvWfl1EZFv4kbSp0TkIvB53KAQqvoI8CRu9P8VoAx8pA1quhf4mIj4QAW4r5lPuMg7gA8Bv4j+Fgb4LHBTqq5WP1ZZamr1Y3UCeEzcZlN9wN+q6hM7nuePAv9dRF7BPc/va2I9WWva98+eLQ03xmRmKz2NMZlZwzDGZGYNwxiTmTUMY0xm1jCMMZlZwzDGZGYNwxiT2f8HwSZD/0TnaggAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 可视化有助于：\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "trishape = plt.Polygon(tri, edgecolor = 'r', alpha = 0.2, lw = 5)\n",
    "_, ax = plt.subplots(figsize = (4, 4))\n",
    "ax.add_patch(trishape)\n",
    "ax.set_ylim([.5, 3.5])\n",
    "ax.set_xlim([.5, 3.5])\n",
    "ax.scatter(*centroid, color = 'g', marker = 'D', s = 70)\n",
    "ax.scatter(*tri.T, color = 'b', s = 70)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {
    "image2.png": {
     "image/png": "/9j/4AAQSkZJRgABAQAASABIAAD/4gz0SUNDX1BST0ZJTEUAAQEAAAzkYXBwbAIQAABtbnRyUkdCIFhZWiAH4gACABsAEQAkAAFhY3NwQVBQTAAAAABBUFBMAAAAAAAAAAAAAAAAAAAAAAAA9tYAAQAAAADTLWFwcGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABFkZXNjAAABUAAAAGJkc2NtAAABtAAAAcpjcHJ0AAADgAAAACN3dHB0AAADpAAAABRyWFlaAAADuAAAABRnWFlaAAADzAAAABRiWFlaAAAD4AAAABRyVFJDAAAD9AAACAxhYXJnAAAMAAAAACB2Y2d0AAAMIAAAADBuZGluAAAMUAAAAD5jaGFkAAAMkAAAACxtbW9kAAAMvAAAAChiVFJDAAAD9AAACAxnVFJDAAAD9AAACAxhYWJnAAAMAAAAACBhYWdnAAAMAAAAACBkZXNjAAAAAAAAAAhEaXNwbGF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbWx1YwAAAAAAAAAjAAAADGhySFIAAAAWAAABtGtvS1IAAAAWAAABtG5iTk8AAAAWAAABtGlkAAAAAAAWAAABtGh1SFUAAAAWAAABtGNzQ1oAAAAWAAABtGRhREsAAAAWAAABtG5sTkwAAAAWAAABtGZpRkkAAAAWAAABtGl0SVQAAAAWAAABtHJvUk8AAAAWAAABtGVzRVMAAAAWAAABtGFyAAAAAAAWAAABtHVrVUEAAAAWAAABtGhlSUwAAAAWAAABtHpoVFcAAAAWAAABtHZpVk4AAAAWAAABtHNrU0sAAAAWAAABtHpoQ04AAAAWAAABtHJ1UlUAAAAWAAABtGZyRlIAAAAWAAABtG1zAAAAAAAWAAABtGhpSU4AAAAWAAABtHRoVEgAAAAWAAABtGNhRVMAAAAWAAABtGVzWEwAAAAWAAABtGRlREUAAAAWAAABtGVuVVMAAAAWAAABtHB0QlIAAAAWAAABtHBsUEwAAAAWAAABtGVsR1IAAAAWAAABtHN2U0UAAAAWAAABtHRyVFIAAAAWAAABtHB0UFQAAAAWAAABtGphSlAAAAAWAAABtABEAEUATABMACAAVQAyADQAMQAyAE0AAHRleHQAAAAAQ29weXJpZ2h0IEFwcGxlIEluYy4sIDIwMTgAAFhZWiAAAAAAAADz2AABAAAAARYIWFlaIAAAAAAAAHAWAAA5RAAAA6NYWVogAAAAAAAAYhoAALdjAAAZCVhZWiAAAAAAAAAkpwAAD1gAALaAY3VydgAAAAAAAAQAAAAABQAKAA8AFAAZAB4AIwAoAC0AMgA2ADsAQABFAEoATwBUAFkAXgBjAGgAbQByAHcAfACBAIYAiwCQAJUAmgCfAKMAqACtALIAtwC8AMEAxgDLANAA1QDbAOAA5QDrAPAA9gD7AQEBBwENARMBGQEfASUBKwEyATgBPgFFAUwBUgFZAWABZwFuAXUBfAGDAYsBkgGaAaEBqQGxAbkBwQHJAdEB2QHhAekB8gH6AgMCDAIUAh0CJgIvAjgCQQJLAlQCXQJnAnECegKEAo4CmAKiAqwCtgLBAssC1QLgAusC9QMAAwsDFgMhAy0DOANDA08DWgNmA3IDfgOKA5YDogOuA7oDxwPTA+AD7AP5BAYEEwQgBC0EOwRIBFUEYwRxBH4EjASaBKgEtgTEBNME4QTwBP4FDQUcBSsFOgVJBVgFZwV3BYYFlgWmBbUFxQXVBeUF9gYGBhYGJwY3BkgGWQZqBnsGjAadBq8GwAbRBuMG9QcHBxkHKwc9B08HYQd0B4YHmQesB78H0gflB/gICwgfCDIIRghaCG4IggiWCKoIvgjSCOcI+wkQCSUJOglPCWQJeQmPCaQJugnPCeUJ+woRCicKPQpUCmoKgQqYCq4KxQrcCvMLCwsiCzkLUQtpC4ALmAuwC8gL4Qv5DBIMKgxDDFwMdQyODKcMwAzZDPMNDQ0mDUANWg10DY4NqQ3DDd4N+A4TDi4OSQ5kDn8Omw62DtIO7g8JDyUPQQ9eD3oPlg+zD88P7BAJECYQQxBhEH4QmxC5ENcQ9RETETERTxFtEYwRqhHJEegSBxImEkUSZBKEEqMSwxLjEwMTIxNDE2MTgxOkE8UT5RQGFCcUSRRqFIsUrRTOFPAVEhU0FVYVeBWbFb0V4BYDFiYWSRZsFo8WshbWFvoXHRdBF2UXiReuF9IX9xgbGEAYZRiKGK8Y1Rj6GSAZRRlrGZEZtxndGgQaKhpRGncanhrFGuwbFBs7G2MbihuyG9ocAhwqHFIcexyjHMwc9R0eHUcdcB2ZHcMd7B4WHkAeah6UHr4e6R8THz4faR+UH78f6iAVIEEgbCCYIMQg8CEcIUghdSGhIc4h+yInIlUigiKvIt0jCiM4I2YjlCPCI/AkHyRNJHwkqyTaJQklOCVoJZclxyX3JicmVyaHJrcm6CcYJ0kneierJ9woDSg/KHEooijUKQYpOClrKZ0p0CoCKjUqaCqbKs8rAis2K2krnSvRLAUsOSxuLKIs1y0MLUEtdi2rLeEuFi5MLoIuty7uLyQvWi+RL8cv/jA1MGwwpDDbMRIxSjGCMbox8jIqMmMymzLUMw0zRjN/M7gz8TQrNGU0njTYNRM1TTWHNcI1/TY3NnI2rjbpNyQ3YDecN9c4FDhQOIw4yDkFOUI5fzm8Ofk6Njp0OrI67zstO2s7qjvoPCc8ZTykPOM9Ij1hPaE94D4gPmA+oD7gPyE/YT+iP+JAI0BkQKZA50EpQWpBrEHuQjBCckK1QvdDOkN9Q8BEA0RHRIpEzkUSRVVFmkXeRiJGZ0arRvBHNUd7R8BIBUhLSJFI10kdSWNJqUnwSjdKfUrESwxLU0uaS+JMKkxyTLpNAk1KTZNN3E4lTm5Ot08AT0lPk0/dUCdQcVC7UQZRUFGbUeZSMVJ8UsdTE1NfU6pT9lRCVI9U21UoVXVVwlYPVlxWqVb3V0RXklfgWC9YfVjLWRpZaVm4WgdaVlqmWvVbRVuVW+VcNVyGXNZdJ114XcleGl5sXr1fD19hX7NgBWBXYKpg/GFPYaJh9WJJYpxi8GNDY5dj62RAZJRk6WU9ZZJl52Y9ZpJm6Gc9Z5Nn6Wg/aJZo7GlDaZpp8WpIap9q92tPa6dr/2xXbK9tCG1gbbluEm5rbsRvHm94b9FwK3CGcOBxOnGVcfByS3KmcwFzXXO4dBR0cHTMdSh1hXXhdj52m3b4d1Z3s3gReG54zHkqeYl553pGeqV7BHtje8J8IXyBfOF9QX2hfgF+Yn7CfyN/hH/lgEeAqIEKgWuBzYIwgpKC9INXg7qEHYSAhOOFR4Wrhg6GcobXhzuHn4gEiGmIzokziZmJ/opkisqLMIuWi/yMY4zKjTGNmI3/jmaOzo82j56QBpBukNaRP5GokhGSepLjk02TtpQglIqU9JVflcmWNJaflwqXdZfgmEyYuJkkmZCZ/JpomtWbQpuvnByciZz3nWSd0p5Anq6fHZ+Ln/qgaaDYoUehtqImopajBqN2o+akVqTHpTilqaYapoum/adup+CoUqjEqTepqaocqo+rAqt1q+msXKzQrUStuK4trqGvFq+LsACwdbDqsWCx1rJLssKzOLOutCW0nLUTtYq2AbZ5tvC3aLfguFm40blKucK6O7q1uy67p7whvJu9Fb2Pvgq+hL7/v3q/9cBwwOzBZ8Hjwl/C28NYw9TEUcTOxUvFyMZGxsPHQce/yD3IvMk6ybnKOMq3yzbLtsw1zLXNNc21zjbOts83z7jQOdC60TzRvtI/0sHTRNPG1EnUy9VO1dHWVdbY11zX4Nhk2OjZbNnx2nba+9uA3AXcit0Q3ZbeHN6i3ynfr+A24L3hROHM4lPi2+Nj4+vkc+T85YTmDeaW5x/nqegy6LzpRunQ6lvq5etw6/vshu0R7ZzuKO6070DvzPBY8OXxcvH/8ozzGfOn9DT0wvVQ9d72bfb794r4Gfio+Tj5x/pX+uf7d/wH/Jj9Kf26/kv+3P9t//9wYXJhAAAAAAADAAAAAmZmAADypwAADVkAABPQAAAKW3ZjZ3QAAAAAAAAAAQABAAAAAAAAAAEAAAABAAAAAAAAAAEAAAABAAAAAAAAAAEAAG5kaW4AAAAAAAAANgAAo8AAAFSAAABMwAAAmYAAACaAAAAPQAAAUEAAAFRAAAIzMwACMzMAAjMzAAAAAAAAAABzZjMyAAAAAAABC7cAAAWW///zVwAABykAAP3X///7t////aYAAAPaAADA9m1tb2QAAAAAAAAQrAAAoHoxVTFTzp3lgAAAAAAAAAAAAAAAAAAAAAD/2wBDAAUDBAQEAwUEBAQFBQUGBwwIBwcHBw8LCwkMEQ8SEhEPERETFhwXExQaFRERGCEYGh0dHx8fExciJCIeJBweHx7/2wBDAQUFBQcGBw4ICA4eFBEUHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh7/wgARCAB1AeADASIAAhEBAxEB/8QAGwABAQADAQEBAAAAAAAAAAAAAAUDBAYCAQf/xAAUAQEAAAAAAAAAAAAAAAAAAAAA/9oADAMBAAIQAxAAAAH9lAAAAAAAAAASPBaRRaRRaRRaRNQ6ZFFpFFpFFpFFpFFpz/w6FFFpFFpFFpFFpFFpFFpFFpFxl5FtHIVYtM8WOAsF/BowjssmnuGXH7nEe7z28WPPC2C6iVyniyYygxckVveWSWqH5l+lnpJ3iXb/AD+ybevmvjT+zDNsaUM67b4XtDNim/T5T4mkeK2rfNPcgVDbag29fxpFiJvzjPV/PLJ1bDOKM1AO35n3kPdwGPINfP8AQ09wAAMeQa3vMPPjKAHHdiGDOMWUHn0MOYMeQAPODZHz6DFlHn57Hj2AAADHkGDOAGL36DFlAAAAAAAAAAABM1C85rbLSKLSKLSKLSKLTT3AAAAAAAAAAAAAAAAAAAAAAACRhy8UdNf9zSunUQAA1+cOraW6AAAAAAAAAAAAAAAAAAAAAaGvXHnWzcQdVF6TizsPfO5Cfr9jpFeVZGt+b/o/wxSau6a26AAAAAAAAAAAAAAAAAAAAAADgu9546GLa0jzj3PJsgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//EACwQAAICAgEDBAECBwEAAAAAAAMEAQIABRUQEhMGERRQICJgFiEjJSYwNHD/2gAIAQEAAQUC/aDNPktcYtnGLZxi2cYtnGLZxi2cYtk61WIXVQPPGLZxi2cYtnGLZxi2cYtnGLZxi2cYtnGLYVFMVQJJGFxi2cYtnGLZxi2cYtnGLZxi2cYtnGLZxi2cYtnGLZxi2cYtnGLYRBMdEAqd2eoHa11rF5Jsp3KvyFGAtruvLqWG0rsM1Z7MokdTHcLC58ZZEO6rZuCYcVRsk8u5bZvA1ywdmqVpC81aOyuCRupkv0GWolViQtr1mwsW6ztUveJzu8Wz1EXsfEyydXaFtQZmAK4swJkPQt6iGDYqmme29KHL8LVU8aLZZCD8GbyNfGryTYtbBVb8DEqIa2xVYnK3ms6iLeLGNe3CH667dQpo9V6xRjTa3ZoHJtfTxv77o6WprCALa4BXHJVzV2vx2V9S+ixO507R6561t/jFE2Xn0o79qcVyTRctblraw9UwWNE2r36q9LNrVmhNDExMTrUZsEQgUXAXYjW8NPUUx5d9h1gGnWIhCtt49s3kHUmw0guGHQw41qEZsjDS1iuut8HR2XITUR3TmyRAUIFwAmq4atDXDRgS4RGfSAYIVVw2PXx7p4FwkC218ow6GHGtQjNueqeqCkYK2sYZuwnHftut6VvFQhrfpKy/5DpUdKABSSDGWKxFaipQdOoli09R54h+w6UHXpMRMDGMUZSlafhaItFgBtSP5dSDoSKxFYtEWrWIrX/Retb1sIV79SDGSIiKxg6VHT/w5wh+8nJDoAzx87drnbtc7drnbtc7drnbtc7drnbtc7dri0MxH19r0q+22iZZYuvAyEwjV+4CKjFdOW+j2hBjJCiAEz689mQfify+F9hY6CPv8L6tkd7yMJYJaYrVY42FdZ/w+qFQOa5KhRKNVtZYlr20GvIKrF+6aQDYe80mV9dSrCyBfOHSCGXVGNRefrSjqUeoma+mjXgAFNj/AFL7utY0zbjxRLwIa2tXCDo0H5C6garLQoMaY6VGP69X9O4wDfdWhZPGqLc+r+3hKf4hwSwBR4qey4Rrh/cH/8QAFBEBAAAAAAAAAAAAAAAAAAAAcP/aAAgBAwEBPwFw/8QAFBEBAAAAAAAAAAAAAAAAAAAAcP/aAAgBAgEBPwFw/8QAShAAAgEDAQQECAoHBAsAAAAAAQIDAAQREiExMtITQVGUBRAUImFxgZEgIzNCUFKTobHBJGJygrLC8BVgotEwNENUY2Rwg+Hi8f/aAAgBAQAGPwL+6CwFpAiJrbQ5Q5+btH71cd33uXmrju+9y81cd33uXmrju+9y81cd33uXmrju+9y81cd33uXmrJkuwB/zkvNTCKa7JXGR5VMN+7rrju+9y81cd33uXmrju+9y81cd33uXmrju+9y81cd33uXmrju+9y81cd33uXmrju+9y81cd33uXmrU8l2NuP8AW5eahLFLdMh6/K5eauO773LzVx3fe5eauO773LzVx3fe5eauO773LzVx3fe5eauO773LzVx3fe5eauO773LzVx3fe5eauO773LzVx3fe5eauO773LzVx3fe5eauO773LzUXeW7Cjr8rl5qMtvJcMVOkh55Dg+pj4rvoJplkhHHGDgN2E1BaAkKEM0npxsA/rsqe3CXLSQcYEJ2UlxbuHjfcajSUsZJTiNFXLNVxaxO+uMDXsKlCd3t2VHK+Ne1Xx9YHB+8UUku4FYbwZBXxM8UmPqMDQhJcyMCQqLk47aRhK7SyzmFHbftlK59gqG2YuZH2RxqCzH01KIGJ6I4fK4weyvKLjX0Y3lVziltvjI5HGqMSIV1j0Vc2ZOREVZP2W6veDQE88URO7W4FBI7uB2O4CQHx3V+w2ec/7q7Pyz7aSW6k898Fzvyx6h+FSLGW1RnDhlIx8CXz2PRbXwh2Dt9Xiktjlo5ojKF9IOG/EVNNJZy2zFVUB9ONIzhRg/wBZ8UcpGCwzUUKMVa4lEWodXWfuBpY2JzpyFVSTgddLLC2pHGV9I8ZkfcKj0M3xpIQlCASOr8aI3qdlTL5Obua2n0LsBPaG2+gikXopItrErJjVkk7Tjt30ZAM7QPv+DJIN6qT4rezBIXSZnx1gYwPefuqTpXPxQzIQpOj1/AMjnYKi6J2xLnQShAON48V9aND5SIsPHH2q25dvpBqWSS3lhkkk1N0mMk4HYTs6vZ4vCFnAsTC5d3V2fGNW/qq3mlUJ0sBjODnDA5A/irwv5IsMrFY+KTG3TVnaIYpSZcS5J6/q1Z+ErbQz2+pWjc41A+mvDbzNEp+LY6WyAADUesFS5aTB6tTFvzosL2dAfmgJs/w0S9zLL6HC/kBXl0Sq+YOiZS2Mbcg0vlCIPJ7rpzobOV6TUfcCfdVv4VtejkKRmNo3bGR6D7a8OTR+T+ULNq0l/N2Vc6sKzaNn7wrwfeTdDHDaoSuh9RckerdV9OODzIh6SuSf4qBW5li/YC/mDQY3s7gdRCbf8NFVcoT84dVNG75uYHNtk/WzhfxFS2UezVAYl92K8HXaacQnpGRjj5pHvBo3kvR9JcXqyjbu+NUbP3RWQcg0WNtHk760xIEXfsrwj0fRrDdTaOk1f7NfNwB7D76nSPQP0aMYHbqelI4beA59bkcvizLGHI7ahJgCyqKtZ/mw3AZvUQV/mq+vk0MZoFhjy2ChyR/MKtbSOXEsbRn07BgKPzoxyLqQ7xWy1jqabzQIo8qPSN1Wa3ZWKG1hbOl9rMRjV6OurmW3fzX0+aNw2fjV3c/NnuCV9QAX+XxMRAGkLA/fRMUYTPZTXIT411ClvQKkuFTEsoAc9uN1SzRph5iC5zvxUzdCGkZD+FaoolU7tlW8x4ZImi9uxh+BoWLaCL6/6Rjq26OLGP3cVGJHGh53TGjqAx/F91GORdSHeK2WsfuqebZ5kfmevqq0kk0RrYwHTpOrLYwW92ffXQ3LAv0CO2Fxhjv/ACq9uPmgJCPZkn+L4GHAO3Na1iQN2hdvjPxEe3f5u/4QRBhRsArKwxrnsWsSRq4/WGa0qAAOoUEjUKo6h8Cbzf0Zwtxn9fBXH5+zxMuhcOcsO2tMaKo7APHgjINYjjVB+qMeI6VA1HJ9J+AVYZBpVeJGC7tQzWB49MiK47CM0AowB1UVO40FUAAbAB/odLDIoO0SMw3Ejb8DTIiuOxhmgAMAeIIihVHUP+h8UNsYhI+SekGfNH/0UXe4sgo/4Lc1fE3lg+wHZE249fFXy9l9i3NXy9l9i3NXy9l9i3NXy9l9i3NXy9l9i3NXy9l9i3NXy9l9i3NXy9l9i3NXy9l9i3NR8paJj1dGpH5/SDySOqJDCPOJ+sf/AFFSwjwhbIXQqG6QbPTTyr4RttLIqBNa7AP6PvrVDKki5xlGz9M3YlUPHLIVwewDT+INf2NdMTaynVaSH+H+vzrEiKw9IqWS2AiSTjjA83Pb6K8o2BJDmP8AZ6j7d/wm6HT0nzc7jUFy0ukSKejjdgoLEdfZioMy9KejXz/rbN/0YNK5/wC8yfhQJTr/AN6c0WY4A31Hcxn4t11A1Ex3uNZ9bbfzroHB6dm/R9O/X/l21FHPL0sqqAz9pqVU4ihArwasRIifolmI6o8bf8qvLiBGRJrlLePo1AxpwDsPpJ91MFbS2Nhxurbfp9h/5oxyyb1wWGyrR7aLEjXZuHIXHRx5Jx7RjZ6aMvnYLtxY6jj8qjMkaOC8jLqXqLnH3VCmhz0jaF0LnHr7B9HGNxlTvFS2ufPieS29urA/EUz6HYIOFFyfYKN1c2HhEzsMAC1bEa/VFbPBvhV/Vampp57WW0hXzI45Bhj2sfu++pI43ZVYkrj5meylhJklVZDINZ25Oc7vWff43hLugcYJXfUdurMyxrpGrso2sGYUIxsO3FLGihVUYAHV9IXlj1NdpN701fivilk0ykdJp0nSMYH9e2mVQ0R7cqf86tJpTqeSFGY+kj6Ybwh8023R+3V4mCRjBYsc7dtEBdOfq7KWGIYRRhRnOP7w/wD/xAAsEAEAAQMDBAEDBAIDAAAAAAABEQAhMUFRYRBxgZGhIFDBMLHh8EBgcNHx/9oACAEBAAE/If8AUDuNx4mLkYtZ2/QGDBgwYMGMwBKtikmHTMC5Q4u/H6YwYMGDBgwYMGRdyBCqugElrCp0b8f4AYMGDBgwYMGDBgwYMGG+WVVJREb6YbR8dJYn3aFJAjUk9xUYAk0I7KVf+i1YxNewdcY/fSaPi0nTvRJomYDanReq5GrAZeqP8cQlR8SUsH4GJ4mnEdysvqkTjCMZswXzUDJd2wCnW54qwNcbmf5NNnxJEhOWpSk5gJ3t4xUwk8BDLI+M0m1hrKEx4B7RVyCAkfdZIFMPieqjr/Aw8MqNzcNY7GW7AOKi0E9W6M/3H0CC2zrN+xsb8UDEIzeiIVJXgAE6OPed6gPxwFgWsSyscOhBpEGlFabZAipzac1nsGrlQNDf80U2Qoi5nt1cxDlgl7Bq8UGxpEApmmbejQUwVV81MK+WAi6FzXXdpq+kUhSJwJTYYmiZIjPIPz9IrCNHgnpfgBUSR2GT+VPQ4ANDiwtO1DIPVMREWJVWADVWjxF1giQUyQ+nbo687sKR2Fs7BG1T0D0xEgAEAJ6HuKo1ITUOKiMpaAJM1t8KhtnDHHYZDWpoS0DDvDWM30GoKMgGNLQYSaAlxyUDe0xaWK3/AEtQgeaLji0N7J+aGjpgQrGxd62DAw7o+KuzJSKqW4RRJTDsTZRAbzspCXgkLBe4S24zQ7UDbzPHNQ1iLgxOEWFNoY7QHzIdxoISFxM1mlxeP9A/NAuSIJeROtPkzVSZz7aC3Uk0lipxB4bm1nRHw0r2rJDIN7B4okAEiOaSqeUmWnUiSMO9E2Ce4hUDWxf4XyQZgXEndiPimv4d9rPT9nQGeIGl6Ph1GnDzP+zJ7F3YqdCU0wFryp4o8LczMYZ0Evoid6G/kmGjbDxSMEysQW+wpaMxsoVKMBXd4uBJbbpAXnEvimuUj7m3syez0VfKdW2filB1juoBxNZuihtrQPpCWz+SryjCMhB2ttTGjwxdbCmbmSdlSCyfaYPJ6aS6eG+IwND4N7SGIKhfJne2O6ZzR380w0bYUEcFoPG33FOdH2c2kRsGrwukEDIUqJwbtW2wx0rbots8w7j9BcqADojI07f8kPakFFC2Oiy32wZTfe59QHTwsBtSBRkgTeaMCjICPmh1iwEBWFoH0B2dvUfZW8HTLqYCRdq1YHCDqyACETNOFRlBHx02LB+x+gaBoRJEoEjwQh7oAAAMHW5wZhChqmgBAFCDIQlDheAgDb9GNOYb7jI1GWOFR5+gmOMwBPmjLAgAsHTFCAP+DwzFEpAvYTWhZgo0piw3MyRuDDfh2/SgQIECBAgQIF43XA+ZX3AzUEICWZdPy1LxgDNLQnTNKZ4hVsTPPs4pubSAM7W+8t5s3pAiglaLc1y/uacAKmKLv4wUOnss+PINkEdd5/S59V5tCRmbcTiaEKG1ExcotzF84rNF6jGL5Z+2JUUL/iC9RKQu/BSGhgClLYKnqjZayTQYyPNyfzSZR/YX/hVmMJRazXzNKw1cIHc7TiYF3qy1+ASGC8m2E6UQkiHlLeNayBOCUZwqDz7m1MGWhhkOwgBmbvV3IoAskgRk3VFDKRhmE8inKYZkWt4bH27FL+gm3ahREKzhusvxBlvwGaInlg+wPK6vARNXNh/vFQfhWpzIOwpAUBBKufZW/wC1qUuv22sQkdeeopNRYA1iRoSRFhMMFgp4SE2RALLwRxRYj44BY+4evX0uPWdMglKBEmFibzN3LQqAlNYPT8qtVVYJCrb7weARM8zMx2jpnqkFxVzi625qzWCFu+y9MbOa4CwX0/2H/9oADAMBAAIAAwAAABDzzzzzzzzzzTzzzTzzzzzTzzzzzzzjTDCjyyhBBjTDTADzQDChyzzyjRzRizywyzzwxwzzzzzzxzxxyxzzzzyxzwzzzzzzzzzzzzzjzzzzzzzzzzzzzzzzzzzzzzzzzzzzyTDDzjjzzzzzzzzzzzzzzzzzzzzzzwCQyzwzBzzzzzzzzzzzzzzzzzzzzzzyzyzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz/xAAUEQEAAAAAAAAAAAAAAAAAAABw/9oACAEDAQE/EHD/xAAUEQEAAAAAAAAAAAAAAAAAAABw/9oACAECAQE/EHD/xAApEAEBAAICAgICAgIBBQAAAAABEQAhMUFRYRBxgZEgUDCxYEBwocHw/9oACAEBAAE/EP8AiD9yHEHUsM1KN6/wf/8A/wD/AP8A/wDSeAaAcq8T3gfqBmNFqQzg1HTP8X//AP8A/wD/AP8A/wD/AP5g9Cn0ECPAPD4cHXDJWJCNCIiOxEf+g/8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8AoIsTDx5rQA5UDJCiiQCvkEd1ETm/FTrUY5Kh+ApyYXUoSWZfJ07kaBCK5NxXjGkTwSMOXaSliiI7EREd0cT+VPQKGsCKsDDdfISOqBQ8NTlcUkQf/hQaA+srswn/AAqjD1Jr+U0zrIShoVESwQVyoFdYW8rkIUBo6JyRN4IhYAHYFYArzR2typR3GwgicCTSJ04QzagEA9BUKwqHKYczNH3klYbqRuTHRWTTiPOqeCetjtlQBOwRcdGETvwCn5RcUSxWxfAT75IMcRF6cdAMsAXDbxAPUlKyOrpXZ/CT9vad1I5EciShcDRghEaefrHDXOCFrSKdKfbK4zcN7mU2DoAAwYOk1F6v1jSiEjzHW7dIdzIyZiIzQqEhXaBUCw0FZUEjGumdnn526TC3gG0YA2qBzkzsrTIiCTV6uRMTAwSgOkp+TKrKdBqolwsIO1odp0k0sJQomk4mHJ8LBH39L9fx4Ga+K4H1r4Z2VakX9CjsY0Qx1J1TbtWk5RGRuFMSliR+V8IlSABVAANqh3g1MDEwBCSJ/sTAKbq6CdAI/oWHFJ6KpJEoDAtVXGq9SbpdbCIYiWIjWe4vYEmzQw5+TK1WeIJTblCRIYAhN4g6XtabcLph0IFBS3IxI62TZj0buxBiBRBvxTHFRIQxl0AieR4yorCP1CwfayUBBsDyUXra4fbSLkSAKQzsWTGVOrdgSqCbvhYGyWJ2EjAlHYOcFhCYwDCHCCCo0XRSQBBqsPIB48OGPtGeiRIbtdndwy6rkoieQF+l04tPQIPy0X6TLIYCPUsj6GTcmArd8DSyiDGPCkimqqkLsRT4V9499wrhtX5MRKzPNwh5MPh51lqFQDkABCSwdqG8A8CsA8I9mIJa1VFV5524txvRVAf0D9YXCVqZaMUMkG69MBkvgjOHsd93NusAaDhoYp2jE6PMfEfsEaHMP3lQgUE3/fvAUhc8yv0E9IuhcRveeqQKkRs2rDea+ETwzG4XQaanDzaHHBEH8hhwndjv+8Nq/YqkR7gPcx3MA0ZSjT6+u8qEoC2lg0jCcEtd4bKS/Wj5QD2DvXwJ9sDzb58HDOWKEgytUjTMKxFbCt7hgm0GyVBFhBGgvdhnCYF1LRUgBoYW2vvd+TQYyF4W1Iz6ofrEj1m4H/6Sz5wIet8xNCAbsnajDQTVYeeB4XDRaECykOuog/kMNE7s2yiivaMB5ePvHjOpW16IKbKrAYULgXzi9HcqmgOHMiRY/tgFeB9IfJwXZsYHhEEfWPj5VJeaCtxYBdSbNdft+BxBInjEINEFHTN/xQSJT3gSt8CyAOgNB0BkTdW+AKhvYP2GQqaIGcgHeHKCJAdAcGVQvJAqq+1VVdqq/wAG+VUaqY4oq+fJ8BIQDqoCq1uF915c2qZ2ae4Evyh4FYB5E7Mrc0QPlAb+L1FUG0lTtgH0BwH8EIwPIERHkfGFMRPsA1tuBv1g0GgEAOvr5Iwxsx5iS7f3glICgOADgy6h7koiJr7w7zQARABoADX+FYuhBwAHhEETYhnHKhetIikVft/hFgyEQgytxd+3Cr+HAiABweviuJNACqr7VVXlVe/+x6MgJbQhdZbZtwT819Ho7qoAbVMRNrUZ0J6rBRQ7f4kaNGjRo0aNGFTpJBNxa3w/j+weGCW8tEP/AEGU9GnumhqkinHJkhoMrxzaCgQjW8J51EpBUpLEZ7P7kMbaQ/8A66cl84m5RdAKnA1k8zWk0uZJ5POk9GHVfEVYJpKQCMWkcJTQc2qI7QaagW0VpZS/wEQRI7JkrSe2CNvQD4LYyOrIzBXFUJYYikSXLo0nsY7PA73/AFjv0Ba+/KPs5CdytIvj/S6xku5YBVXo1cjgTunMeE7+nOHYqcIH9mCTaJCSKJxACp0FdIYdo59UBn2nPf5wHFKBjZH1tMDj9kIULsUhqD4zgLYKYAgRBXdDI4nAVGKiBjKWdYQPbBB/N5OyX6ER3Ng21kxzvlRGEPsgKFYoqaDjVNapFVEbEwXBOCngNDwfXOHpGFOhwAIr69z+tCkGtSoq8qROEUaLmxIxFB3nXE+PeL9vJFDRCp0B/oy9uVPI151Dpx0cNJwx9/qxiPcF6gNSA0aV6JC9Ui1IkkgQVOAD8adQ6Ic4G6jiB8JQOjLwQClLLFkYjuhe1sSTQBxwFrXDkRNZxWoyC3QnBgjGUgQDwAB+P7CzuYnJSh6/OPv4voL6kBZKBSAJocEJSj2w4DX6T7yeVR0N4AVVgBv+4j282insoRfb7+D7xp1Wi2KIgKgVxE12RU/CPw5ON4CwFagAA6n/ACH/2Q=="
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "许多**聚类算法**利用点集合的欧几里得距离，或者指向远点，或者相对于它们的质心。\n",
    "\n",
    "在笛卡尔坐标下，p 点和 q 点之间的欧几里德距离：\n",
    "\n",
    "![image2.png](attachment:image2.png)\n",
    "\n",
    "因此，对于上面的三坐标集，每个点到原点(0, 0)的欧几里德距离是："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.41421356, 3.16227766, 3.60555128])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(tri ** 2, axis = 1) ** 0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.41421356, 3.16227766, 3.60555128])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 寻找符合欧几里德的规则：\n",
    "\n",
    "np.linalg.norm(tri, axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.20185043, 1.20185043, 1.33333333])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 找到相对于三角形质心的每个点的范数，而不是参考原点：\n",
    "\n",
    "np.linalg.norm(tri - centroid, axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 5.99361355  5.46345071]\n",
      " [ 6.08041142  4.52470525]\n",
      " [ 8.91653938  6.75116156]\n",
      " [ 5.88096818  4.68106998]\n",
      " [ 3.75146719  4.22200593]\n",
      " [ 9.17829844 10.70649676]\n",
      " [10.62237931  8.87219494]\n",
      " [ 8.69209713 11.46048261]\n",
      " [ 9.50925483  8.70701024]\n",
      " [ 9.83770665  9.2083858 ]]\n",
      "[[ 5  5]\n",
      " [10 10]]\n"
     ]
    }
   ],
   "source": [
    "# 假设有一个二维数组 X 和一个多个 (x, y)“建议”质心的二维数组。\n",
    "# 计算每个质心中每个点的欧几里德距离：\n",
    "\n",
    "X = np.repeat([[5, 5], [10, 10]], [5, 5], axis = 0)\n",
    "X = X + np.random.randn(*X.shape)\n",
    "centroids = np.array([[5, 5], [10, 10]])\n",
    "print(X)\n",
    "print(centroids)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 5  5]]\n",
      "\n",
      " [[10 10]]]\n",
      "(2, 1, 2)\n"
     ]
    }
   ],
   "source": [
    "# 进行一些重构以在此启用广播：\n",
    "\n",
    "print(centroids[:, None])\n",
    "print(centroids[:, None].shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.1 , 1.18, 4.29, 0.94, 1.47, 7.07, 6.83, 7.44, 5.84, 6.41],\n",
       "       [6.05, 6.73, 3.42, 6.73, 8.51, 1.08, 1.29, 1.96, 1.38, 0.81]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 能够使用一个数组行的组合乘积，从另一个数组中清清楚楚地减掉这些数组：\n",
    "\n",
    "np.linalg.norm(X - centroids[:, None], axis = 2).round(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 1, 0, 0, 1, 1, 1, 1, 1], dtype=int64)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# X-质心[:, None] 的形状是(2, 10, 2)，本质上表示两个堆叠的数组，每个数组的大小都为 X。\n",
    "# 希望每个最近的质心的标签（索引号），从上面的数组找出第 0 轴上的最小距离：\n",
    "\n",
    "np.argmin(np.linalg.norm(X - centroids[:, None], axis = 2), axis = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 将所有这些以函数形式组合在一起\n",
    "\n",
    "def get_labels(X, centroids) -> np.ndarray:\n",
    "    return np.argmin(np.linalg.norm(X - centroids[:, None], axis = 2), axis = 0)\n",
    "labels = get_labels(X, centroids)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 用一个颜色映射来绘制两个集群和它们指定的标签：\n",
    "\n",
    "c1, c2 = ['#bc13fe', '#be0119']\n",
    "llim, ulim = np.trunc([X.min() * 0.9, X.max() * 1.1])\n",
    "\n",
    "_, ax = plt.subplots(figsize = (5, 5))\n",
    "ax.scatter(*X.T, c = np.where(labels, c2, c1), alpha = 0.4, s = 80)\n",
    "ax.scatter(*centroids.T, c = [c1, c2], marker = 's',s = 95, edgecolor = 'yellow')\n",
    "ax.set_ylim([llim, ulim])\n",
    "ax.set_xlim([llim, ulim])\n",
    "ax.set_title('One K-Means Iteration: Predicted Classes')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 摊还（分期）表\n",
    "\n",
    "矢量化也适用于金融领域。\n",
    "\n",
    "给定年利率，支付频率（每年的次数），初始贷款余额和贷款期限，你可以矢量化方式创建包含月贷款余额和付款的摊还表。让我们设置一些标量常量："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "freq = 12     # 12 months per year\n",
    "rate = .0675  # 6.75% annualized\n",
    "nper = 30     # 30 years\n",
    "pv = 200000   # Loan face value\n",
    "\n",
    "rate /= freq  # Monthly basis\n",
    "nper *= freq  # 360 months"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy 预装了一些[财务函数](https://www.jianshu.com/p/4317f5c2cafe)，与**Excel表兄弟**不同，它们能够以矢量的形式输出。\n",
    "\n",
    "债务人（或承租人）每月支付一笔由本金和利息部分组成的固定金额。由于未偿还的贷款余额下降，总付款的利息部分随之下降。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "periods = np.arange(1, nper +  1, dtype = int)\n",
    "principal = np.ppmt(rate, periods, nper, pv)\n",
    "interest = np.ipmt(rate, periods, nper, pv)\n",
    "pmt = principal + interest\n",
    "# Or: pmt = np.pmt(rate, nper, pv)"
   ]
  },
  {
   "attachments": {
    "image3.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来，需要计算每月的月，包括支付前和付款后的余额，可以定义为**原始余额的未来价值减去年金（支付流）的未来价值**，使用折扣因子 d:\n",
    "\n",
    "![image3.png](attachment:image3.png)\n",
    "\n",
    "从功能上看，如下所示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def balance(pv, rate, nper, pmt) -> np.ndarray:\n",
    "    d = (1 + rate) ** nper\n",
    "    return pv * d - pmt * (d - 1) / rate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最后，可以使用 Pandas 的 **DataFrame** 将其放到表格格式中。小心这里的标志。从债务人角度看，PMT是一种流出。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "         beg_bal     prin  interest    end_bal\n",
      "month                                         \n",
      "1      200000.00  -172.20  -1125.00  199827.80\n",
      "2      199827.80  -173.16  -1124.03  199654.64\n",
      "3      199654.64  -174.14  -1123.06  199480.50\n",
      "...          ...      ...       ...        ...\n",
      "358      3848.22 -1275.55    -21.65    2572.67\n",
      "359      2572.67 -1282.72    -14.47    1289.94\n",
      "360      1289.94 -1289.94     -7.26      -0.00\n",
      "\n",
      "[360 rows x 4 columns]\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "cols = ['beg_bal', 'prin', 'interest', 'end_bal']\n",
    "data = [balance(pv, rate, periods - 1, -pmt),\n",
    "       principal,\n",
    "       interest,\n",
    "       balance(pv, rate, periods, -pmt)]\n",
    "\n",
    "table = pd.DataFrame(data, columns = periods, index = cols).T\n",
    "table.index.name = 'month'\n",
    "\n",
    "with pd.option_context('display.max_rows', 6):\n",
    "    # Note: Using floats for $$ in production-level code = bad\n",
    "    print(table.round(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# At the end of year 30, the loan is paid off:\n",
    "final_month = periods[-1]\n",
    "np.allclose(table.loc[final_month, 'end_bal'], 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 注意：\n",
    "\n",
    "虽然使用浮点数代表资金对于脚本环境中的概念说明非常有用，但在生产环境中使用 Python 浮点数进行财务计算可能会导致计算在某些情况下损失一两分钱。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 图像特征提取\n",
    "\n",
    "最后一个例子中，我们将处理 1941 年 10 月莱克星顿号航空母舰 (CV-2) 的照片，这艘船的残骸是 2018 年 3 月在澳大利亚海岸外发现的。首先，我们可以将图像映射到它的像素值的NumPy数组中："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from skimage import io\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "url = ('https://www.history.navy.mil/bin/imageDownload?image=/'\n",
    "       'content/dam/nhhc/our-collections/photography/images/'\n",
    "       '80-G-410000/80-G-416362&rendition=cq5dam.thumbnail.319.319.png')\n",
    "img = io.imread(url, as_grey = True)\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "ax.imshow(img, cmap = 'gray')\n",
    "ax.grid(False)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "为了简单起见，图像是以灰度加载的，结果是一个由 64 位浮点数组成的 2d 数组，而不是一个三维 mxnx4rgba 数组，更低的值表示暗点："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(254, 319)\n",
      "0.027450980392156862\n",
      "1.0\n",
      "[0.80784314 0.79607843 0.78039216 0.78823529 0.79607843 0.80784314\n",
      " 0.80392157 0.79215686 0.79607843 0.79607843]\n",
      "[0.07843137 0.07843137 0.07058824 0.07058824 0.0745098  0.07058824\n",
      " 0.0745098  0.07843137 0.07843137 0.08235294]\n"
     ]
    }
   ],
   "source": [
    "print(img.shape)\n",
    "print(img.min())\n",
    "print(img.max())\n",
    "print(img[0, :10])\n",
    "print(img[-1, -10:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在图像分析中，一种常用的中间步骤是贴片提取。顾名思义，这包括从较大的数组中提取较小的重叠子阵列，并可用于有利于“去噪”或模糊图像的情况。\n",
    "\n",
    "这一概念也扩展到其他领域。例如，你可以通过使用具有多个特性（变量）的时间序列的“滚动”窗口来做类似的事情。它甚至对构建**康威的“生命游戏”**很有用。（不过，与 3×3 内核的**卷积**是一种更直接的方法。）\n",
    "\n",
    "在这里，我们将找到 img 中每个重叠的 10×10 修补的平均值。以一个微型示例为例，img 左上角的第一个 3×3 修补程序矩阵将是："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.80784314 0.79607843 0.78039216]\n",
      " [0.80392157 0.81568627 0.80784314]\n",
      " [0.78823529 0.8        0.79607843]]\n",
      "0.7995642701525054\n"
     ]
    }
   ],
   "source": [
    "print(img[:3, :3])\n",
    "print(img[:3, :3].mean())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "用于创建滑动修复方式的纯 Python 方法将涉及嵌套的 for 循环。你需要考虑最右边补丁的起始索引是在索引 n - 3 + 1，其中 n 是数组的宽度。换句话说，如果你从名为 arr 的 10×10 阵列中提取 3×3 修复，那么最后一个修复将来自 arr\\[7: 10, 7: 10]。 还要记住，Python 的 range() 不包含其 stop 参数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "size = 10\n",
    "m, n = img.shape\n",
    "mm, nn = m - size + 1, n - size + 1\n",
    "\n",
    "patch_means = np.empty((mm, nn))\n",
    "for i in range(mm):\n",
    "    for j in range(nn):\n",
    "        patch_means[i, j] = img[i: i + size, j: j + size].mean()\n",
    "        \n",
    "fig, ax = plt.subplots()\n",
    "ax.imshow(patch_means, cmap = 'gray')\n",
    "ax.grid(False)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "有了这个循环，就可以执行很多 Python 调用。\n",
    "\n",
    "另一种可扩展到更大 RGB 或 RGBA 图像的替代方案是 NumPy 的 stride_tricks。\n",
    "\n",
    "一个有益的第一步是在给定修补大小和图像形状的情况下，可视化更高维度的修复矩阵。我们有一个 2d 阵列 img 形状（254, 319）和一个（10, 10）2d 修复，这意味着我们的输出形状（在取每个“内部”* 10x10 *数组的平均值之前）将是："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(245, 310, 10, 10)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shape = (img.shape[0] - size + 1, img.shape[1] - size + 1, size, size)\n",
    "shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "还需要指定新数组的**步长**。数组的步长是一个字节元组，用于在沿数组移动时跳转到每个维度。IMG 中的每个像素都是 64 位（8 字节）的浮点，这意味着总的图像大小为 254×319×8 = 648, 208 字节。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "float64\n",
      "648208\n"
     ]
    }
   ],
   "source": [
    "print(img.dtype)\n",
    "print(img.nbytes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在内部，IMG 作为一个连续的 648，208 字节块保存在内存中。因此，STEAMS 是一种类似“元数据”的属性，它告诉我们需要向前跳转多少字节才能沿着每个轴移动到下一个位置。我们沿着行以 8 字节为单位移动，但需要遍历 8×319=2，552 字节才能将“向下”从一行移动到另一行。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2552, 8)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "img.strides"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在我们的示例中，生成的修复程序的步调只会重复 img 的两次步调："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2552, 8, 2552, 8)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "strides = 2 * img.strides\n",
    "strides"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "将这些部分与 NumPy 的 stride_tricks 结合起来："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(245, 310, 10, 10)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[0.81, 0.8 , 0.78, 0.79, 0.8 , 0.81, 0.8 , 0.79, 0.8 , 0.8 ],\n",
       "       [0.8 , 0.82, 0.81, 0.79, 0.79, 0.79, 0.78, 0.81, 0.81, 0.8 ],\n",
       "       [0.79, 0.8 , 0.8 , 0.79, 0.8 , 0.8 , 0.82, 0.83, 0.79, 0.81],\n",
       "       [0.8 , 0.79, 0.81, 0.81, 0.8 , 0.8 , 0.78, 0.76, 0.8 , 0.79],\n",
       "       [0.78, 0.8 , 0.8 , 0.78, 0.8 , 0.79, 0.78, 0.78, 0.79, 0.79],\n",
       "       [0.8 , 0.8 , 0.78, 0.78, 0.78, 0.8 , 0.8 , 0.8 , 0.81, 0.79],\n",
       "       [0.78, 0.77, 0.78, 0.76, 0.77, 0.8 , 0.8 , 0.77, 0.8 , 0.8 ],\n",
       "       [0.79, 0.76, 0.77, 0.78, 0.77, 0.77, 0.79, 0.78, 0.77, 0.76],\n",
       "       [0.78, 0.75, 0.76, 0.76, 0.73, 0.75, 0.78, 0.76, 0.77, 0.77],\n",
       "       [0.78, 0.79, 0.78, 0.78, 0.78, 0.78, 0.77, 0.76, 0.77, 0.77]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from numpy.lib import stride_tricks\n",
    "\n",
    "patches = stride_tricks.as_strided(img, shape = shape, strides = strides)\n",
    "print(patches.shape)\n",
    "\n",
    "patches[0, 0].round(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最后一步，为了得到每个内部 10×10 阵列的矢量化平均值，我们需要仔细考虑我们现在拥有的维数。结果应该折叠最后两个维度，以便我们留下一个 254×310 阵列。\n",
    "\n",
    "一种（次优）方式是首先重塑修复，将内部 2d 数组展平为长度为 100 的向量，然后计算最终轴上的均值："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(245, 310)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "veclen = size ** 2\n",
    "patches.reshape(*patches.shape[:2], veclen).mean(axis = -1).shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "也可以将轴定为元组，计算最后两个轴的平均值，这应该比重新整形更有效："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(245, 310)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "patches.mean(axis = (-1, -2)).shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过比较与循环版本的相等性来确保检查："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "strided_means = patches.mean(axis = (-1, -2))\n",
    "np.allclose(patch_means, strided_means)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "至此，Scikit-Learn 已经在其 feature_extraction 模块中很好地嵌入了整个过程。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 最后：不要过度优化\n",
    "\n",
    "利用 NumPy 中的数组编程来优化运行时。在处理大型数据集时，注意微观性能非常重要。\n",
    "\n",
    "但是，有一部分案例无法避免使用本机 Python for 循环。正如 Donald Knuth 所说，“过早优化是所有邪恶的根源。”程序员可能错误地预测他们的代码中会出现瓶颈的地方，花费数小时试图完全矢量化操作，这将导致运行时相对不显着的改进。\n",
    "\n",
    "在这里或那里都放上 for 循环也没有任何问题。通常，考虑在更高的抽象级别优化整个脚本的流程和结构，可能会更有效率。"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
